class_name CharacterStats
extends Stats

@export_group("Visuals")
@export var character_name: String
@export_multiline var description: String
@export var portrait: Texture

@export_group("Gameplay Data")
@export var starting_deck: CardPile
@export var draftable_cards: CardPile
@export var cards_per_turn: int
@export var max_mana: int
@export var starting_relic: Relic

var mana: int : set = set_mana
# 贷款能量系统
var old_loan_mana: int = 0  # 上回合的贷款，影响当前回合可用能量
var new_loan_mana: int = 0  # 本回合新增的贷款
#当前卡组
var deck: CardPile
#弃牌堆
var discard: CardPile
#抽牌堆
var draw_pile: CardPile

# 获取实际可用的能量（考虑贷款影响）
func get_available_mana() -> int:
	return clampi(mana - old_loan_mana, 0, max_mana)

# 获取普通卡牌的可用能量（不考虑贷款影响）
# 注意：这个方法主要用于特殊情况下需要忽略贷款影响的场景
# 一般情况下应该使用 get_available_mana() 来检查卡牌可玩性
func get_regular_mana() -> int:
	return clampi(mana, 0, max_mana)

# 获取贷款卡牌的可用能量（考虑贷款影响）
func get_loan_mana() -> int:
	return clampi(mana - old_loan_mana, 0, max_mana)

# 检查回合开始时的能量状态（用于防止可用能量为0时仍能打牌）
func check_turn_start_mana() -> void:
	var available_mana = get_available_mana()
	print("🔍 回合开始能量检查: mana=%d, old_loan_mana=%d, 可用能量=%d" % [mana, old_loan_mana, available_mana])
	
	if available_mana <= 0:
		print("⚠️ 警告：回合开始时可用能量为0，玩家将无法打出任何卡牌")
		# 不在这里发出信号，让调用者统一处理
		# stats_changed.emit()

#设置能量
func set_mana(value: int) -> void:
	var old_mana = mana
	mana = value
	
	# 通过追踪器记录变化
	if stats_tracker:
		stats_tracker.track_mana_change(old_mana, mana)
	
	stats_changed.emit()

#重置能量
func reset_mana() -> void:
	var old_mana = mana
	
	print("🔍 reset_mana() 开始")
	print("📊 贷款状态: old_loan_mana=%d, new_loan_mana=%d" % [old_loan_mana, new_loan_mana])
	
	# 回合开始时：old_loan_mana = new_loan_mana, new_loan_mana = 0
	old_loan_mana = new_loan_mana
	new_loan_mana = 0
	
	# 重置到最大能量
	mana = max_mana
	
	print("🔄 贷款转移: 新的 old_loan_mana=%d, new_loan_mana=%d" % [old_loan_mana, new_loan_mana])
	print("⚡ 能量状态: 基础能量=%d, 贷款影响=%d, 实际可用=%d" % [mana, old_loan_mana, get_available_mana()])
	
	# 不在这里发出信号，让调用者统一处理
	# stats_changed.emit()
	
	# 通过追踪器记录变化（在set_mana中已经处理）

# 贷款能量系统完成，以下为卡牌相关追踪方法

# 消耗能量（打出卡牌时调用）- 支持贷款能量
func spend_mana(amount: int, allow_loan: bool = false) -> bool:
	if amount <= 0:
		return true
	
	var available_mana = get_available_mana()
	print("💰 尝试消耗能量: 需要=%d, 实际可用=%d, 允许贷款=%s" % [amount, available_mana, "是" if allow_loan else "否"])
	
	if available_mana >= amount:
		# 正常消耗：从实际能量中扣除
		mana -= amount
		
		# 记录正常能量消耗
		if stats_tracker:
			var counter = stats_tracker.get_turn_counter()
			if counter:
				counter.add_to_counter(TurnCounter.CounterType.MANA_SPENT, amount)
		
		print("✅ 正常消耗 %d 点能量，剩余可用能量=%d" % [amount, get_available_mana()])
		
		# 立即触发状态变化信号，确保卡牌UI及时更新可玩性状态
		stats_changed.emit()
		return true
	else:
		# 能量不足
		if allow_loan:
			# 贷款消耗：记录到new_loan_mana
			var loan_amount = amount - available_mana
			var normal_spent = available_mana
			
			# 消耗所有可用能量
			mana -= normal_spent
			
			# 增加新贷款
			var old_new_loan = new_loan_mana
			new_loan_mana += loan_amount
			
			# 记录到计数器
			if stats_tracker:
				var counter = stats_tracker.get_turn_counter()
				if counter:
					if normal_spent > 0:
						counter.add_to_counter(TurnCounter.CounterType.MANA_SPENT, normal_spent)
					# 记录贷款能量到过量消耗计数器
					counter.add_to_counter(TurnCounter.CounterType.MANA_OVERSPENT, loan_amount)
			
			print("⚡ 贷款消耗: 正常消耗=%d, 贷款=%d" % [normal_spent, loan_amount])
			print("📊 贷款累积: new_loan_mana %d → %d (+%d)" % [old_new_loan, new_loan_mana, loan_amount])
			
			# 立即触发状态变化信号，确保卡牌UI及时更新可玩性状态
			stats_changed.emit()
			return true
		else:
			print("❌ 能量不足且不允许贷款")
			return false
#是否存在
# 检查是否可以支付能量成本（包括贷款能量）
func can_afford_mana(amount: int, allow_loan: bool = false) -> bool:
	if allow_loan:
		return true  # 贷款能量总是可以进行
	else:
		return get_available_mana() >= amount

# 获得能量
func gain_mana(amount: int) -> void:
	if amount <= 0:
		return
	mana += amount
	
	# 立即触发状态变化信号，确保卡牌UI及时更新可玩性状态
	stats_changed.emit()

func track_card_played(card_cost: int = 0, card_effect_value: int = 1) -> void:
	if stats_tracker:
		stats_tracker.track_card_played()
		# 如果有资源追踪器，也记录卡牌效率
		var resource_tracker = stats_tracker.get_resource_tracker()
		if resource_tracker:
			resource_tracker.track_card_played(card_cost, card_effect_value)

func track_cards_drawn(amount: int = 1) -> void:
	if stats_tracker:
		stats_tracker.track_cards_drawn(amount)

func track_cards_discarded(amount: int = 1) -> void:
	if stats_tracker:
		stats_tracker.track_cards_discarded(amount)

# 重置回合计数器（覆盖父类方法）
func reset_turn_counters() -> void:
	super.reset_turn_counters()
	
	# 设置资源追踪器的回合开始状态
	if stats_tracker:
		var resource_tracker = stats_tracker.get_resource_tracker()
		if resource_tracker:
			# 使用实际可用能量而不是基础能量
			resource_tracker.set_turn_start_state(get_available_mana(), 0)  # 假设手牌数为0，实际应该传入真实值

# 回合结束时计算资源浪费
func end_turn_resource_calculation() -> void:
	if stats_tracker:
		var resource_tracker = stats_tracker.get_resource_tracker()
		if resource_tracker:
			# 使用实际可用能量而不是基础能量
			resource_tracker.calculate_turn_end_waste(get_available_mana())

# 获取资源使用建议
func get_resource_advice() -> String:
	if stats_tracker:
		var resource_tracker = stats_tracker.get_resource_tracker()
		if resource_tracker:
			return resource_tracker.get_resource_advice()
	return "无追踪数据"


func take_damage(damage: int) -> void:
	var initial_health := health
	super.take_damage(damage)
	if initial_health > health:
		Events.player_hit.emit()


#判断能否打出当前卡牌
func can_play_card(card: Card) -> bool:
	# 卡牌可玩性检查应该考虑贷款影响，与UI显示保持一致
	var available_mana = get_available_mana()
	var can_play = available_mana >= card.cost
	
	print("🔍 can_play_card 检查: 卡牌=%s, 费用=%d, 可用能量=%d, 可打出=%s" % [
		card.id, card.cost, available_mana, "是" if can_play else "否"
	])
	print("📊 能量状态: mana=%d, old_loan_mana=%d, new_loan_mana=%d" % [
		mana, old_loan_mana, new_loan_mana
	])
	
	return can_play

# 新增：检查卡牌是否可玩（考虑修改器影响）
func can_play_card_with_modifiers(card: Card, modifier_handler: ModifierHandler) -> bool:
	if not modifier_handler:
		# 如果没有modifier_handler，回退到基础检查
		return can_play_card(card)
	
	var effective_cost = card.cost
	var cost_modifier = modifier_handler.get_modifier(Modifier.Type.CARD_COST)
	if cost_modifier:
		var cost_increase = cost_modifier.get_modified_value(0)
		effective_cost += cost_increase
	
	var available_mana = get_available_mana()
	return available_mana >= effective_cost

#创建角色实例
func create_instance() -> Resource:
	var instance: CharacterStats = self.duplicate()
	instance.health = max_health
	instance.block = 0
	instance.old_loan_mana = 0  # 确保新实例的贷款为0
	instance.new_loan_mana = 0
	instance.reset_mana()
		# 创建新的空牌堆
	instance.deck = CardPile.new()
		# 为每张卡牌创建独立副本
	for card in starting_deck.cards:
		# 检查卡牌是否为null，避免调用duplicate方法时出错
		if card != null:
			instance.deck.add_card_copy(card)
		else:
			print("⚠️ 警告：在create_instance中发现null卡牌，跳过复制")
	instance.draw_pile = CardPile.new()
	instance.discard = CardPile.new()
	return instance

# 回合结束时的贷款能量处理
func end_turn_loan_cleanup() -> void:
	print("🔄 回合结束贷款能量检查...")
	print("📊 当前贷款状态: old_loan_mana=%d, new_loan_mana=%d" % [old_loan_mana, new_loan_mana])
	
	# 玩家回合结束后：old_loan_mana = 0
	old_loan_mana = 0
	print("🧹 已清零 old_loan_mana，new_loan_mana 保持为: %d" % new_loan_mana)
	
	# 触发UI更新（因为old_loan_mana清零可能影响显示）
	stats_changed.emit()
